home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / distutils / command / build_py.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  11KB  |  332 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. """distutils.command.build_py
  5.  
  6. Implements the Distutils 'build_py' command."""
  7. __revision__ = '$Id: build_py.py,v 1.46 2004/11/10 22:23:15 loewis Exp $'
  8. import sys
  9. import string
  10. import os
  11. from types import *
  12. from glob import glob
  13. from distutils.core import Command
  14. from distutils.errors import *
  15. from distutils.util import convert_path
  16. from distutils import log
  17.  
  18. class build_py(Command):
  19.     description = '"build" pure Python modules (copy to build directory)'
  20.     user_options = [
  21.         ('build-lib=', 'd', 'directory to "build" (copy) to'),
  22.         ('compile', 'c', 'compile .py to .pyc'),
  23.         ('no-compile', None, "don't compile .py files [default]"),
  24.         ('optimize=', 'O', 'also compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0]'),
  25.         ('force', 'f', 'forcibly build everything (ignore file timestamps)')]
  26.     boolean_options = [
  27.         'compile',
  28.         'force']
  29.     negative_opt = {
  30.         'no-compile': 'compile' }
  31.     
  32.     def initialize_options(self):
  33.         self.build_lib = None
  34.         self.py_modules = None
  35.         self.package = None
  36.         self.package_data = None
  37.         self.package_dir = None
  38.         self.compile = 0
  39.         self.optimize = 0
  40.         self.force = None
  41.  
  42.     
  43.     def finalize_options(self):
  44.         self.set_undefined_options('build', ('build_lib', 'build_lib'), ('force', 'force'))
  45.         self.packages = self.distribution.packages
  46.         self.py_modules = self.distribution.py_modules
  47.         self.package_data = self.distribution.package_data
  48.         self.package_dir = { }
  49.         if self.distribution.package_dir:
  50.             for name, path in self.distribution.package_dir.items():
  51.                 self.package_dir[name] = convert_path(path)
  52.             
  53.         
  54.         self.data_files = self.get_data_files()
  55.         if type(self.optimize) is not IntType:
  56.             
  57.             try:
  58.                 self.optimize = int(self.optimize)
  59.             except (ValueError, AssertionError):
  60.                 raise DistutilsOptionError, 'optimize must be 0, 1, or 2'
  61.             except:
  62.                 None<EXCEPTION MATCH>(ValueError, AssertionError)
  63.             
  64.  
  65.         None<EXCEPTION MATCH>(ValueError, AssertionError)
  66.  
  67.     
  68.     def run(self):
  69.         if self.py_modules:
  70.             self.build_modules()
  71.         
  72.         if self.packages:
  73.             self.build_packages()
  74.             self.build_package_data()
  75.         
  76.         self.byte_compile(self.get_outputs(include_bytecode = 0))
  77.  
  78.     
  79.     def get_data_files(self):
  80.         """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
  81.         data = []
  82.         if not self.packages:
  83.             return data
  84.         
  85.         for package in self.packages:
  86.             src_dir = self.get_package_dir(package)
  87.             build_dir = os.path.join(*[
  88.                 self.build_lib] + package.split('.'))
  89.             plen = len(src_dir) + 1
  90.             filenames = [ file[plen:] for file in self.find_data_files(package, src_dir) ]
  91.             data.append((package, src_dir, build_dir, filenames))
  92.         
  93.         return data
  94.  
  95.     
  96.     def find_data_files(self, package, src_dir):
  97.         """Return filenames for package's data files in 'src_dir'"""
  98.         globs = self.package_data.get('', []) + self.package_data.get(package, [])
  99.         files = []
  100.         for pattern in globs:
  101.             filelist = glob(os.path.join(src_dir, convert_path(pattern)))
  102.             [](_[1])
  103.         
  104.         return files
  105.  
  106.     
  107.     def build_package_data(self):
  108.         '''Copy data files into build directory'''
  109.         lastdir = None
  110.         for package, src_dir, build_dir, filenames in self.data_files:
  111.             for filename in filenames:
  112.                 target = os.path.join(build_dir, filename)
  113.                 self.mkpath(os.path.dirname(target))
  114.                 self.copy_file(os.path.join(src_dir, filename), target, preserve_mode = False)
  115.             
  116.         
  117.  
  118.     
  119.     def get_package_dir(self, package):
  120.         """Return the directory, relative to the top of the source
  121.            distribution, where package 'package' should be found
  122.            (at least according to the 'package_dir' option, if any)."""
  123.         path = string.split(package, '.')
  124.         if not self.package_dir:
  125.             if path:
  126.                 return apply(os.path.join, path)
  127.             else:
  128.                 return ''
  129.         else:
  130.             tail = []
  131.             while path:
  132.                 
  133.                 try:
  134.                     pdir = self.package_dir[string.join(path, '.')]
  135.                 except KeyError:
  136.                     tail.insert(0, path[-1])
  137.                     del path[-1]
  138.                     continue
  139.  
  140.                 tail.insert(0, pdir)
  141.                 return apply(os.path.join, tail)
  142.             pdir = self.package_dir.get('')
  143.             if pdir is not None:
  144.                 tail.insert(0, pdir)
  145.             
  146.             if tail:
  147.                 return apply(os.path.join, tail)
  148.             else:
  149.                 return ''
  150.  
  151.     
  152.     def check_package(self, package, package_dir):
  153.         if package_dir != '':
  154.             if not os.path.exists(package_dir):
  155.                 raise DistutilsFileError, "package directory '%s' does not exist" % package_dir
  156.             
  157.             if not os.path.isdir(package_dir):
  158.                 raise DistutilsFileError, ("supposed package directory '%s' exists, " + 'but is not a directory') % package_dir
  159.             
  160.         
  161.         if package:
  162.             init_py = os.path.join(package_dir, '__init__.py')
  163.             if os.path.isfile(init_py):
  164.                 return init_py
  165.             else:
  166.                 log.warn("package init file '%s' not found " + '(or not a regular file)', init_py)
  167.         
  168.  
  169.     
  170.     def check_module(self, module, module_file):
  171.         if not os.path.isfile(module_file):
  172.             log.warn('file %s (for module %s) not found', module_file, module)
  173.             return 0
  174.         else:
  175.             return 1
  176.  
  177.     
  178.     def find_package_modules(self, package, package_dir):
  179.         self.check_package(package, package_dir)
  180.         module_files = glob(os.path.join(package_dir, '*.py'))
  181.         modules = []
  182.         setup_script = os.path.abspath(self.distribution.script_name)
  183.         for f in module_files:
  184.             abs_f = os.path.abspath(f)
  185.             if abs_f != setup_script:
  186.                 module = os.path.splitext(os.path.basename(f))[0]
  187.                 modules.append((package, module, f))
  188.                 continue
  189.             self.debug_print('excluding %s' % setup_script)
  190.         
  191.         return modules
  192.  
  193.     
  194.     def find_modules(self):
  195.         '''Finds individually-specified Python modules, ie. those listed by
  196.         module name in \'self.py_modules\'.  Returns a list of tuples (package,
  197.         module_base, filename): \'package\' is a tuple of the path through
  198.         package-space to the module; \'module_base\' is the bare (no
  199.         packages, no dots) module name, and \'filename\' is the path to the
  200.         ".py" file (relative to the distribution root) that implements the
  201.         module.
  202.         '''
  203.         packages = { }
  204.         modules = []
  205.         for module in self.py_modules:
  206.             path = string.split(module, '.')
  207.             package = string.join(path[0:-1], '.')
  208.             module_base = path[-1]
  209.             
  210.             try:
  211.                 (package_dir, checked) = packages[package]
  212.             except KeyError:
  213.                 package_dir = self.get_package_dir(package)
  214.                 checked = 0
  215.  
  216.             if not checked:
  217.                 init_py = self.check_package(package, package_dir)
  218.                 packages[package] = (package_dir, 1)
  219.                 if init_py:
  220.                     modules.append((package, '__init__', init_py))
  221.                 
  222.             
  223.             module_file = os.path.join(package_dir, module_base + '.py')
  224.             if not self.check_module(module, module_file):
  225.                 continue
  226.             
  227.             modules.append((package, module_base, module_file))
  228.         
  229.         return modules
  230.  
  231.     
  232.     def find_all_modules(self):
  233.         """Compute the list of all modules that will be built, whether
  234.         they are specified one-module-at-a-time ('self.py_modules') or
  235.         by whole packages ('self.packages').  Return a list of tuples
  236.         (package, module, module_file), just like 'find_modules()' and
  237.         'find_package_modules()' do."""
  238.         modules = []
  239.         if self.py_modules:
  240.             modules.extend(self.find_modules())
  241.         
  242.         if self.packages:
  243.             for package in self.packages:
  244.                 package_dir = self.get_package_dir(package)
  245.                 m = self.find_package_modules(package, package_dir)
  246.                 modules.extend(m)
  247.             
  248.         
  249.         return modules
  250.  
  251.     
  252.     def get_source_files(self):
  253.         modules = self.find_all_modules()
  254.         filenames = []
  255.         for module in modules:
  256.             filenames.append(module[-1])
  257.         
  258.         return filenames
  259.  
  260.     
  261.     def get_module_outfile(self, build_dir, package, module):
  262.         outfile_path = [
  263.             build_dir] + list(package) + [
  264.             module + '.py']
  265.         return apply(os.path.join, outfile_path)
  266.  
  267.     
  268.     def get_outputs(self, include_bytecode = 1):
  269.         modules = self.find_all_modules()
  270.         outputs = []
  271.         for package, module, module_file in modules:
  272.             package = string.split(package, '.')
  273.             filename = self.get_module_outfile(self.build_lib, package, module)
  274.             outputs.append(filename)
  275.             if include_bytecode:
  276.                 if self.compile:
  277.                     outputs.append(filename + 'c')
  278.                 
  279.                 if self.optimize > 0:
  280.                     outputs.append(filename + 'o')
  281.                 
  282.             self.optimize > 0
  283.         
  284.         [] += [ os.path.join(build_dir, filename) for package, src_dir, build_dir, filenames in self.data_files for filename in filenames ]
  285.         return outputs
  286.  
  287.     
  288.     def build_module(self, module, module_file, package):
  289.         if type(package) is StringType:
  290.             package = string.split(package, '.')
  291.         elif type(package) not in (ListType, TupleType):
  292.             raise TypeError, "'package' must be a string (dot-separated), list, or tuple"
  293.         
  294.         outfile = self.get_module_outfile(self.build_lib, package, module)
  295.         dir = os.path.dirname(outfile)
  296.         self.mkpath(dir)
  297.         return self.copy_file(module_file, outfile, preserve_mode = 0)
  298.  
  299.     
  300.     def build_modules(self):
  301.         modules = self.find_modules()
  302.         for package, module, module_file in modules:
  303.             self.build_module(module, module_file, package)
  304.         
  305.  
  306.     
  307.     def build_packages(self):
  308.         for package in self.packages:
  309.             package_dir = self.get_package_dir(package)
  310.             modules = self.find_package_modules(package, package_dir)
  311.             for package_, module, module_file in modules:
  312.                 self.build_module(module, module_file, package)
  313.             
  314.         
  315.  
  316.     
  317.     def byte_compile(self, files):
  318.         byte_compile = byte_compile
  319.         import distutils.util
  320.         prefix = self.build_lib
  321.         if prefix[-1] != os.sep:
  322.             prefix = prefix + os.sep
  323.         
  324.         if self.compile:
  325.             byte_compile(files, optimize = 0, force = self.force, prefix = prefix, dry_run = self.dry_run)
  326.         
  327.         if self.optimize > 0:
  328.             byte_compile(files, optimize = self.optimize, force = self.force, prefix = prefix, dry_run = self.dry_run)
  329.         
  330.  
  331.  
  332.